MethodInfoFilter.java

/*******************************************************************************
 * Copyright (c) 2000, 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 
 *******************************************************************************/
package org.eclipse.dltk.internal.corext.util;

import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.search.*;
import org.eclipse.dltk.internal.ui.util.StringMatcher;

public class MethodInfoFilter {

	private static class PatternMatcher {

		private String fPattern;
		private int fMatchKind;
		private StringMatcher fStringMatcher;

		private static final char END_SYMBOL = '<';
		private static final char ANY_STRING = '*';
		private static final char BLANK = ' ';

		public PatternMatcher(String pattern, boolean ignoreCase) {
			this(pattern, SearchPattern.R_EXACT_MATCH
					| SearchPattern.R_PREFIX_MATCH
					| SearchPattern.R_PATTERN_MATCH
					| SearchPattern.R_CAMELCASE_MATCH);
		}

		public PatternMatcher(String pattern, int allowedModes) {
			initializePatternAndMatchKind(pattern);
			fMatchKind = fMatchKind & allowedModes;
			if (fMatchKind == SearchPattern.R_PATTERN_MATCH) {
				fStringMatcher = new StringMatcher(fPattern, true, false);
			}
		}

		public String getPattern() {
			return fPattern;
		}

		public int getMatchKind() {
			return fMatchKind;
		}

		public boolean matches(String text) {
			switch (fMatchKind) {
			case SearchPattern.R_PATTERN_MATCH:
				return fStringMatcher.match(text);
			case SearchPattern.R_EXACT_MATCH:
				return fPattern.equalsIgnoreCase(text);
			case SearchPattern.R_CAMELCASE_MATCH:
				if (SearchPattern.camelCaseMatch(fPattern, text)) {
					return true;
				}
				// fall through to prefix match if camel case failed (bug
				// 137244)
			default:
				return Strings.startsWithIgnoreCase(text, fPattern);
			}
		}

		private void initializePatternAndMatchKind(String pattern) {
			int length = pattern.length();
			if (length == 0) {
				fMatchKind = SearchPattern.R_EXACT_MATCH;
				fPattern = pattern;
				return;
			}
			char last = pattern.charAt(length - 1);

			if (pattern.indexOf('*') != -1 || pattern.indexOf('?') != -1) {
				fMatchKind = SearchPattern.R_PATTERN_MATCH;
				switch (last) {
				case END_SYMBOL:
					fPattern = pattern.substring(0, length - 1);
					break;
				case BLANK:
					fPattern = pattern.trim();
					break;
				case ANY_STRING:
					fPattern = pattern;
					break;
				default:
					fPattern = pattern + ANY_STRING;
				}
				return;
			}

			if (last == END_SYMBOL) {
				fMatchKind = SearchPattern.R_EXACT_MATCH;
				fPattern = pattern.substring(0, length - 1);
				return;
			}

			if (last == BLANK) {
				fMatchKind = SearchPattern.R_EXACT_MATCH;
				fPattern = pattern.trim();
				return;
			}

			if (SearchUtils.isCamelCasePattern(pattern)) {
				fMatchKind = SearchPattern.R_CAMELCASE_MATCH;
				fPattern = pattern;
				return;
			}

			fMatchKind = SearchPattern.R_PREFIX_MATCH;
			fPattern = pattern;
		}
	}

	private String fText;
	private IDLTKSearchScope fSearchScope;
	private boolean fIsWorkspaceScope;
	private int fElementKind;

	private PatternMatcher fPackageMatcher;
	private PatternMatcher fNameMatcher;

	private static final int METHOD_MODIFIERS = 0;

	public MethodInfoFilter(String text, IDLTKSearchScope scope, int elementKind) {
		fText = text;
		fSearchScope = scope;
		fIsWorkspaceScope = fSearchScope.equals(SearchEngine
				.createWorkspaceScope(scope.getLanguageToolkit()));
		fElementKind = elementKind;

		//		int index= text.lastIndexOf("."); //$NON-NLS-1$
		// if (index == -1) {\
		if (DLTKCore.DEBUG) {
			System.err.println("TODO: Add check here..."); //$NON-NLS-1$
		}
		fNameMatcher = new PatternMatcher(text, true);
		// } else {
		// fPackageMatcher= new
		// PatternMatcher(evaluatePackagePattern(text.substring(0, index)),
		// true);
		// String name= text.substring(index + 1);
		// if (name.length() == 0)
		//				name= "*"; //$NON-NLS-1$
		// fNameMatcher= new PatternMatcher(name, true);
		// }
	}

	// /*
	// * Transforms o.e.j to o*.e*.j*
	// */
	// private String evaluatePackagePattern(String s) {
	// StringBuffer buf= new StringBuffer();
	// boolean hasWildCard= false;
	// for (int i= 0; i < s.length(); i++) {
	// char ch= s.charAt(i);
	// if (ch == '.') {
	// if (!hasWildCard) {
	// buf.append('*');
	// }
	// hasWildCard= false;
	// } else if (ch == '*' || ch =='?') {
	// hasWildCard= true;
	// }
	// buf.append(ch);
	// }
	// if (!hasWildCard) {
	// buf.append('*');
	// }
	// return buf.toString();
	// }

	public String getText() {
		return fText;
	}

	public boolean isSubFilter(String text) {
		if (!fText.startsWith(text))
			return false;

		return fText.indexOf('.', text.length()) == -1;
	}

	public boolean isCamelCasePattern() {
		return fNameMatcher.getMatchKind() == SearchPattern.R_CAMELCASE_MATCH;
	}

	public String getPackagePattern() {
		if (fPackageMatcher == null)
			return null;
		return fPackageMatcher.getPattern();
	}

	public String getNamePattern() {
		return fNameMatcher.getPattern();
	}

	public int getSearchFlags() {
		return fNameMatcher.getMatchKind();
	}

	public int getPackageFlags() {
		if (fPackageMatcher == null)
			return SearchPattern.R_EXACT_MATCH;

		return fPackageMatcher.getMatchKind();
	}

	public boolean matchesRawNamePattern(MethodNameMatch method) {
		return Strings.startsWithIgnoreCase(method.getSimpleMethodName(),
				fNameMatcher.getPattern());
	}

	public boolean matchesCachedResult(MethodNameMatch method) {
		if (!(matchesPackage(method) && matchesFilterExtension(method)))
			return false;
		return matchesName(method);
	}

	public boolean matchesHistoryElement(MethodNameMatch method) {
		if (!(matchesPackage(method) && matchesModifiers(method)
				&& matchesScope(method) && matchesFilterExtension(method)))
			return false;
		return matchesName(method);
	}

	public boolean matchesFilterExtension(MethodNameMatch method) {
		return true;
	}

	private boolean matchesName(MethodNameMatch method) {
		return fNameMatcher.matches(method.getSimpleMethodName());
	}

	private boolean matchesPackage(MethodNameMatch method) {
		if (fPackageMatcher == null)
			return true;
		return fPackageMatcher.matches(method.getMethodContainerName());
	}

	private boolean matchesScope(MethodNameMatch method) {
		if (fIsWorkspaceScope)
			return true;
		return fSearchScope.encloses(method.getMethod());
	}

	private boolean matchesModifiers(MethodNameMatch method) {
		if (fElementKind == IDLTKSearchConstants.METHOD)
			return true;
		int modifiers = method.getModifiers() & METHOD_MODIFIERS;
		switch (fElementKind) {
		case IDLTKSearchConstants.METHOD:
			return modifiers == 0;
		}
		return false;
	}
}